//<?php
//  //require_once "base.class.php";
//
//  /**
//   * This class implements typed string objects.<br />
//   * Store the string to work on in private.<br />
//   *
//   * @param string $string The string to work on, this parameter is optional.
//   *
//   * @author Dany Mottier
//   * @version 2.2.4
//   */
//  class String extends Base {
//    /**
//     * The string to work on.
//     * @var string The string to work on.
//     */
//    private $string = "";
//
//    /**
//     * Store the string to work on in private.<br />
//     * @param string $string the string to work on.
//     */
//    public function __construct($string = "") {
//      if (is_string($string))
//        $this->string = $string;
//    }
//
//    /**
//     * Return the string to be printed.<br />
//     * @return string The main string.
//     */
//    public function __toString() {
//      return $this->string;
//    }
//
//    /**
//     * Quote string with slashes.<br />
//     * @return string Returns the escaped string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.addslashes.php">addslashes()</a>
//     */
//    public function AddSlashes() {
//      return addslashes($this->string);
//    }
//
//    /**
//     * Return ASCII value of the character $char.<br />
//     * @param char $char A character.
//     * @return integer Returns the ASCII value.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.ord.php">ord()</a>
//     */
//    public function Ascii($char) {
//      if (is_string($char))
//        return ord($char);
//    }
//
//    /**
//     * Cast a variable into string.<br />
//     * @param mixed $value The variable to cast.
//     * @return string The variable casted into a string.<br />
//     */
//    public function Cast($value) {
//      return strval($value);
//    }
//
//    /**
//     * Return a specific character.<br />
//     * @param integer $ascii The ascii code.
//     * @return string Returns the specified character.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.chr.php">chr()</a>
//     */
//    public function Char($ascii) {
//      if (is_int($ascii))
//        return chr($ascii);
//    }
//
//    /**
//     * Return the character at the position $index.<br />
//     * @param integer $index The position of the searched character.
//     * @return char Returns the char at the position $position.
//     */
//    public function CharAt($index) {
//      if (is_int($index))
//        return $this->string[$index];
//    }
//
//    /**
//     * Binary safe string comparison.<br />
//     *
//     * @param string $string The second string to compare to.
//     * @param boolean $sensitive Define if the comparison must be sensitive case.<br />
//     * This parameter is set to FALSE by default.
//     *
//     * @return integer Bigger than 0 if the main string is less than the second one<br />
//     * Less than 0 if the main string is greater than the second one<br />
//     * 0 if they are equal.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.strcmp.php">strcmp()</a>
//     */
//    public function CompareTo($string, $sensitive = FALSE) {
//      if (is_string($string) && is_bool($sensitive)) {
//        if ($sensitive)
//          return strcmp($this->string, $string);
//        else
//          return strcasecmp($this->string, $string);
//      }
//    }
//
//    /**
//     * Concatenate a string to the main string.<br />
//     * @param string $string The string to concatenate to the main string.
//     */
//    public function Concatenate($string) {
//      if (is_string($string))
//        $this->string .= $string;
//    }
//
//    /**
//     * Find length of initial segment not matching mask.<br />
//     *
//     * @param string $string The string that musn't match the main string.
//     * @param integer $start The start position of the string to examine.
//     * @param integer $length The length of the string to examine.
//     *
//     * @return integer Returns the length of the segment as an integer.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.strcspn.php">strcspn()</a>
//     */
//    public function Exclude($string, $start = 0, $length = -1) {
//      if (is_string($string) && is_int($start) && is_float($length)) {
//        if ($length == -1)
//          return strcspn($this->string,
//                         $string,
//                         $start,
//                         strlen($this->string));
//        else
//          return strcspn($this->string, $string, $start, $length);
//      }
//    }
//
//    /**
//     * Split a string by string.<br />
//     *
//     * @param string $delimiter The boundary string.
//     * @param string $limit If limit is set, the returned array will contain a
//     * maximum of limit elements with the last element containing the rest of
//     * string.<br />If the limit parameter is negative, all components except
//     * the last -limit are returned.
//     *
//     * @return mixed If $delimiter is an empty string (""), Explode() will return
//     * FALSE. <br />If $delimiter contains a value that is not contained in the
//     * main string, then Explode() will return an array containing the main string.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.explode.php">explode()</a>
//     */
//    public function Explode($delimiter, $limit = NULL) {
//      if (is_string($delimiter))
//        if (! empty($limit))
//          if (is_int($limit))
//            return explode($delimiter, $this->string, $limit);
//        else
//          return explode($delimiter, $this->string);
//    }
//
//    /**
//     * Make a string's first character uppercase.<br />
//     * @return string Returns the resulting string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.ucfirst.php">ucfirst()</a>
//     */
//    public function FirstToUpper() {
//      return ucfirst($this->string);
//    }
//
//    /**
//     * Get string length.<br />
//     * @return integer The length of the string on success, and 0 if the string
//     * is empty.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.strlen.php">strlen()</a>
//     */
//    public function getLength() {
//      return strlen($this->string);
//    }
//
//    /**
//     * Parse a CSV string into an array.<br />
//     * @param string $delimiter This function is currently not documented.<br />
//     * Only its argument list is available.
//     * @return array This function is currently not documented; only its
//     * argument list is available.<br /><br />
//     * @see <a href="http://fr2.php.net/manual/en/function.str-getcsv.php">str_getcsv()</a>
//     */
//    public function GetCSV($delimiter = ";") {
//      if (is_string($delimiter))
//        return str_getcsv($this->string, $delimiter);
//    }
//
//    /**
//     * Join array elements with a string.<br />
//     *
//     * @param string $glue Defaults to an empty string. This is not the
//     * preferred usage of Implode() as $glue would be the second parameter and
//     * thus, the bad prototype would be used.
//     * @param array $pieces The array of strings to implode.
//     *
//     * @return string Returns a string containing a string representation of all
//     * the array elements in the same order, with the glue string between each
//     * element.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.implode.php">implode()</a>
//     */
//    public function Implode($glue, $pieces) {
//      if (is_string($glue) && is_array($pieces))
//        return implode($glue, $pieces);
//    }
//
//    /**
//     * Returns the string without any modification.<br />
//     * @return string Returns the string without any modification.
//     */
//    public function In() {
//      return $this->string;
//    }
//
//    /**
//     * Find position of first occurrence of a string.<br />
//     *
//     * @param mixed $needle If $needle is not a string, it is converted to an
//     * integer and applied as the ordinal value of a character.
//     * @param integer $offset The optional $offset parameter allows you to
//     * specify which character in haystack to start searching. The position
//     * returned is still relative to the beginning of haystack .
//     * @param boolean $sensitive Define if the search must be sensitive case.
//     *
//     * @return mixed Returns the position as an integer. If $needle is not
//     * found, IndexOf() will return boolean FALSE.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.strpos.php">strpos()</a>
//     * @see <a href="http://fr.php.net/manual/en/function.stripos.php">stripos()</a>
//     */
//    public function IndexOf($needle, $offset = 0, $sensitive = FALSE) {
//      if (is_string($needle) && is_int($offset) && is_bool($sensitive)) {
//        if ($sensitive)
//          return intval(strpos($this->string, $needle, $offset));
//        else
//          return intval(stripos($this->string, $needle, $offset));
//      }
//    }
//
//    /**
//     * Determine whether the string is empty.<br />
//     * @return boolean True if the string is null.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.empty.php">empty()</a>
//     */
//    public function IsNull() {
//      return empty($this->string);
//    }
//
//    /**
//     * Join array elements with a string.<br />
//     *
//     * @param string $glue Defaults to an empty string. This is not the
//     * preferred usage of Implode() as $glue would be the second parameter and
//     * thus, the bad prototype would be used.
//     * @param array $pieces The array of strings to implode.
//     *
//     * @return string Returns a string containing a string representation of all
//     * the array elements in the same order, with the glue string between each
//     * element.<br /><br />
//     *
//     * @see Implode()
//     * @see <a href="http://fr.php.net/manual/en/function.implode.php">implode()</a>
//     */
//    public function Join($glue, $pieces) {
//      if (is_string($glue) && is_array($pieces))
//        return $this->Implode($glue, $pieces);
//    }
//
//    /**
//     * Returns the position of the last occurence of $needle in the string.<br />
//     *
//     * @param string $needle The searched string.
//     *
//     * @return integer A positive value if $needle is found, otherwise -1
//     * if not found.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.ereg.php">ereg()</a>
//     * @see <a href="Push one or more elements onto the end of array">array_push()</a>
//     * @see <a href="Count elements in an array, or properties in an object">count()</a>
//     */
//    public function LastIndexOf($needle) {
//      if (is_string($needle)) {
//        if (ereg($needle, $this->string)) {
//          $matchs = array();
//
//          for ($i = 0; $i < strlen($this->string); ++$i)
//            if ($this->string[$i] == $needle)
//              array_push($matchs, $i);
//
//          return $matchs[count($matchs) - 1];
//        }
//        else
//          return -1;
//      }
//    }
//
//    /**
//     * Returns the length of the string.<br />
//     * @return integer The length of the string.
//     */
//    public function Length() {
//      return strlen($this->string);
//    }
//
//    /**
//     * Calculate the md5 hash of a string.<br />
//     * @return string Returns the hash as a 32-character hexadecimal number.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.md5.php">md5()</a>
//     */
//    public function MD5() {
//      return md5($this->string);
//    }
//
//    /**
//     * Pad a string to a certain length with another string.<br />
//     *
//     * @param integer $length If the value of $length is negative or less than
//     * the length of the input string, no padding takes place.
//     * @param char $char The character to replace.
//     *
//     * @return string Returns the padded string.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-pad.php">str_pad()</a>
//     */
//    public function Pad($length, $char) {
//      if (is_int($length) && is_string($char))
//        return str_pad($this->string, $length, $char, STR_PAD_BOTH);
//    }
//
//    /**
//     * Pad a string to a certain length with another string.<br />
//     *
//     * @param integer $length If the value of $length is negative or less than
//     * the length of the input string, no padding takes place.
//     * @param char $char The character to replace.
//     *
//     * @return string Returns the padded string.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-pad.php">str_pad()</a>
//     */
//    public function PadLeft($length, $char) {
//      if (is_int($length) && is_string($string))
//        return str_pad($this->string, $length, $char, STR_PAD_LEFT);
//    }
//
//    /**
//     * Pad a string to a certain length with another string.<br />
//     *
//     * @param integer $length If the value of $length is negative or less than
//     * the length of the input string, no padding takes place.
//     * @param char $char The character to replace.
//     *
//     * @return string Returns the padded string.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-pad.php">str_pad()</a>
//     */
//    public function PadRight($length, $char) {
//      if (is_int($length) && is_scalar($string))
//        return str_pad($this->string, $length, $char, STR_PAD_RIGHT);
//    }
//
//    /**
//     * Replace all occurrences of the search string with the replacement string.<br />
//     *
//     * @param string $search The string to replace.
//     * @param string $replace The replacement string.
//     * @param boolean $sensitive Define if the search must be boolean.
//     *
//     * @return string This function returns a string with the replaced values.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-replace.php">str_replace()</a>
//     * @see <a href="http://fr.php.net/manual/en/function.str-ireplace.php">str_ireplace()</a>
//     */
//    public function Replace($search, $replace, $sensitive = FALSE) {
//      if (is_string($search) && is_string($replace) && is_bool($sensitive))
//        if ($sensitive)
//          return str_ireplace($search, $replace, $this->string);
//        else
//          return str_replace($search, $replace, $this->string);
//    }
//
//    /**
//     * Repeat the string.<br />
//     * @param integer $multiplier Number of time the string should be repeated.
//     * @return string Returns the repeated string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.str-repeat.php">str_repeat()</a>
//     */
//    public function Repeat($multiplier) {
//      if (is_int($multiplier))
//        return str_repeat($this->string, $multiplier);
//    }
//
//    /**
//     * Reverse a string.<br />
//     * @return string Returns the reversed string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.strrev.php">strrev()</a>
//     */
//    public function Reverse() {
//      return strrev($this->string);
//    }
//
//    /**
//     * Find first occurrence of a string.<br />
//     *
//     * @param string $needle If $needle is not a string, it is converted to an
//     * integer and applied as the ordinal value of a character.
//     * @param boolean $before_needle
//     *
//     * @return string If TRUE (the default is FALSE), Search() returns the part
//     * of the haystack before the first occurence of the needle.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.strstr.php">strstr()</a>
//     */
//    public function Search($needle, $before_needle = FALSE) {
//      if (is_string($needle) && is_bool($before_needle))
//        return strstr($this->string, $needle, $before_needle);
//    }
//
//    /**
//     * Calculate the similarity between two strings.<br />
//     *
//     * @param string $comparison The string for the comparison.
//     * @param boolean $percent By passing a reference as third argument,
//     * SimilarTo() will calculate the similarity in percent for you.
//     *
//     * @return integer Returns the number of matching chars in both strings.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.similar-text.php">similar_text()</a>
//     */
//    public function SimilarTo($comparison, $percent = FALSE) {
//      if (is_string($comparison) && is_bool($percent))
//        if (! $percent)
//          return similar_text($this->string, $comparison);
//        else {
//          $percent = 0;
//
//          similar_text($this->string, $comparison, $percent);
//
//          return $percent;
//        }
//    }
//
//    /**
//     * Randomly shuffles a string.<br />
//     * @return string Returns the shuffled string.<br /><br />
//     * @see <a ref="http://fr.php.net/manual/en/function.str-shuffle.php">str_shuffle()</a>
//     */
//    public function Shuffle() {
//      return str_shuffle($this->string);
//    }
//
//    /**
//     * Convert a string to an array.<br />
//     *
//     * @param integer $length Maximum length of the chunk.
//     * @return array If the optional $length parameter is specified, the
//     * returned array will be broken down into chunks with each being $length
//     * in length, otherwise each chunk will be one character in length.<br /><br />
//     * FALSE is returned if $length is less than 1. <br /><br />
//     * If the $length exceeds the length of string, the entire string is
//     * returned as the first (and only) array element.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-split.php">str_split()</a>
//     */
//    public function Split($length = NULL) {
//      if (! empty ($length))
//        if (is_int($length))
//          return str_split($this->string);
//    }
//
//    /**
//     * Un-quotes a quoted string.<br />
//     * @return string Returns a string with backslashes stripped off.
//     * (\' becomes ' and so on.) Double backslashes (\\) are made into a single
//     * backslash (\).<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.stripslashes.php">stripslashes()</a>
//     */
//    public function StripSlashes() {
//      return stripslashes($this->string);
//    }
//
//    /**
//     * Binary safe comparison of 2 strings from an offset, up to length
//     * characters/<br />
//     *
//     * @param string $string The string for the comparison.
//     * @param integer $length The length of the comparison.
//     * @param integer $offset The start position for the comparison. <br />
//     * If negative, it starts counting from the end of the string.
//     * @param boolean $sensitive Define if the comparison must be sensitive.
//     *
//     * @return mixed Returns Bigger than 0 if $string from position
//     * $offset is less than $string<br /><br />
//     * Less than 0 if it is greater than the main string.<br /><br />
//     * 0 if they are equal. If $length is equal or greater than length of the
//     * main string and $length is set, SubstringCompare() prints warning and
//     * returns FALSE.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.substr-compare.php">substr_compare()</a>
//     */
//    public function SubstringCompare($string, $length, $sensitive, $offset = 0) {
//      if (is_string($string) && is_int($offset) && is_int($length) && is_bool($sensitive))
//        return substr_compare($this->string,
//                              $string,
//                              $offset,
//                              $length,
//                              $sensitive);
//    }
//
//    /**
//     * Replace text within a portion of a string.<br />
//     *
//     * @param string $replacement The replacement string.
//     * @param integer $start If start is positive, the replacing will begin at
//     * the start 'th offset into string.<br /><br />
//     * If start is negative, the replacing will begin at the start 'th character
//     * from the end of string .
//     * @param integer $length If given and is positive, it represents the length of the portion of string  which is to be replaced. If it is negative, it represents the number of characters from the end of string  at which to stop replacing. If it is not given, then it will default to strlen( string  ); i.e. end the replacing at the end of string . Of course, if length  is zero then this function will have the effect of inserting replacement  into string  at the given start  offset.
//     *
//     * @return string The result string is returned.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.substr-replace.php">substr_replace()</a>
//     */
//    public function SubstringReplace($replacement, $start = 0, $length = -1) {
//      if (is_string($replacement) && is_int($start) && is_int($length))
//        if ($length == -1)
//          return substr_replace($this->string, $replacement, $start);
//        else
//          return substr_replace($this->string, $replacement, $start, $length);
//    }
//
//    /**
//     * Returns the portion of string specified by the $start and $length parameters.<br />
//     *
//     * @param integer $start If $start is non-negative, the returned string will
//     * start at the start 'th position in string, counting from zero. For
//     * instance, in the string 'abcdef', the character at position 0 is 'a', the
//     * character at position 2 is 'c', and so forth.<br /><br />
//     * If start is negative, the returned string will start at the start 'th
//     * character from the end of string .<br /><br />
//     * If string is less than or equal to start characters long, FALSE will be
//     * returned.
//     *
//     * @param integer $length If $length is given and is positive, the string
//     * returned will contain at most length  characters beginning from start
//     * (depending on the length of string ).<br /><br />
//     * If length is given and is negative, then that many characters will be
//     * omitted from the end of string (after the start position has been
//     * calculated when a start is negative).<br /><br />
//     * If start denotes a position beyond this truncation, an empty string will
//     * be returned.
//     *
//     * @return string Returns the extracted part of string.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.substr.php">substr()</a>
//     */
//    public function Substring($start, $length = 0) {
//      if (is_int($start) && is_int($length))
//        if ($length > 0)
//          return substr($this->string, $start, $length);
//        else
//          return substr($this->string, $start);
//    }
//
//    /**
//     * Tokenize string.<br />
//     * @param string $token The delimiter used when splitting up the main string.
//     * @return string A string token.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.strtok.php">strtok()</a>
//     */
//    public function Tokenize($token) {
//      if (is_string($token))
//        return strtok($this->string, $token);
//    }
//
//    /**
//     * Make a string lowercase.<br />
//     * @return string Returns the lowercased string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.strtolower.php">strtolower()</a>
//     */
//    public function ToLower() {
//      return strtolower($this->string);
//    }
//
//    /**
//     * Make a string's first character lowercase.<br />
//     * @return string Returns the resulting string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.lcfirst.php">lcfirst()</a>
//     */
//    public function ToLowerFirst() {
//      return lcfirst($this->string);
//    }
//
//    /**
//     * Make a string uppercase.<br />
//     * @return string Returns the uppercased string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.strtoupper.php">strtoupper()</a>
//     */
//    public function ToUpper() {
//      return strtoupper($this->string);
//    }
//
//    /**
//     * Make a string's first character uppercase.<br />
//     * @return string Returns the resulting string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.ucfirst.php">ucfirst()</a>
//     */
//    public function ToUpperFirst() {
//      return ucfirst($this->string);
//    }
//
//    /**
//     * Strip whitespace (or other characters) from the beginning and end of a string.<br />
//     * @param string $charlist Optionally, the stripped characters can also be
//     * specified using the $charlist parameter. Simply list all characters that
//     * you want to be stripped. With .. you can specify a range of characters.
//     * @return string The trimmed string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.trim.php">trim()</a>
//     */
//    public function Trim($charlist = NULL) {
//      if (! empty($charlist))
//        if (is_string($charlist))
//          return trim($this->string, $charlist);
//      else
//        return trim($this->string);
//    }
//
//    /**
//     * Strip whitespace (or other characters) from the beginning and end of a string.<br />
//     * @param string $charlist Optionally, the stripped characters can also be
//     * specified using the $charlist parameter. Simply list all characters that
//     * you want to be stripped. With .. you can specify a range of characters.
//     * @return string The trimmed string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.trim.php">trim()</a>
//     */
//    public function TrimEnd($charlist = NULL) {
//      if (! empty($charlist))
//        if (is_string($charlist))
//          return rtrim($this->string, $charlist);
//      else
//        return rtrim($this->string);
//    }
//
//    /**
//     * Strip whitespace (or other characters) from the beginning and end of a string.<br />
//     * @param string $charlist Optionally, the stripped characters can also be
//     * specified using the $charlist parameter. Simply list all characters that
//     * you want to be stripped. With .. you can specify a range of characters.
//     * @return string The trimmed string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.trim.php">trim()</a>
//     */
//    public function TrimStart($charlist = NULL) {
//      if (! empty($charlist))
//        if (is_string($charlist))
//          return ltrim($this->string, $charlist);
//      else
//        return ltrim($this->string);
//    }
//
//    /**
//     * Return information about words used in a string.<br />
//     *
//     *  @param integer $format Specify the return value of this function. The
//     * current supported values are:
//     * <li>0 - returns the number of words found </li>
//     * <li>1 - returns an array containing all the words found inside the string</li>
//     * <li>2 - returns an associative array, where the key is the numeric
//     * position of the word inside the string  and the value is the actual word itself </li>
//     * @param string $charlist A list of additional characters which will be considered as 'word'
//     *
//     * @return array Returns an array or an integer, depending on the format chosen.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.str-word-count.php">str_word_count()</a>
//     */
//    public function WordCount($format = __WORDCOUNT, $charlist = NULL) {
//      if (is_int($format) && is_string($charlist))
//        if (! empty($charlist))
//          return str_word_count($this->string, $format, $charlist);
//        else
//          return str_word_count($this->string, $format);
//    }
//
//    /**
//     * Uppercase the first character of each word in a string.<br />
//     * @return string Returns the modified string.<br /><br />
//     * @see <a href="http://fr.php.net/manual/en/function.ucwords.php">ucwords</a>
//     */
//    public function WordsToUpper() {
//      return ucwords($this->string);
//    }
//
//    /**
//     * Wraps a string to a given number of characters.<br />
//     *
//     * @param integer $width The column width. Defaults to 75.
//     * @param string $break The line is broken using the optional $break
//     * parameter. Defaults to '\n'.
//     * @param boolean $cut If the $cut is set to TRUE, the string is always
//     * wrapped at the specified width. So if you have a word that is larger than
//     * the given width, it is broken apart.
//     *
//     * @return string Returns the given string wrapped at the specified column.<br /><br />
//     *
//     * @see <a href="http://fr.php.net/manual/en/function.wordwrap.php">wordwrap()</a>
//     */
//    public function WordWrap($width = 75, $break = "\n", $cut = FALSE) {
//      if (is_int($width) && is_string($break) && is_bool($cut))
//        return wordwrap($this->string, $width, $break, $cut);
//    }
//  }
//?>
